home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-01 / flilib.zip / FLIDOC.TXT < prev    next >
Text File  |  1993-02-09  |  45KB  |  1,334 lines
  1.  
  2.  
  3.  
  4.  
  5.  
  6.  
  7.  
  8.  
  9.  
  10.  
  11.  
  12.                 Turbo C FLI Library Documentation
  13.            For FLI Files Created by Autodesk Animator
  14.  
  15.                         November 20, 1989
  16.  
  17.  
  18.  
  19.  
  20.  
  21.  
  22.  
  23.  
  24.  
  25.  
  26.  
  27.  
  28.  
  29.  
  30.  
  31.  
  32.  
  33.  
  34.  
  35.  
  36.  
  37.  
  38.  
  39.  
  40.  
  41.  
  42.  
  43.  
  44.  
  45.  
  46.  
  47.  
  48.  
  49.  
  50. Copyright 1989-1990 Dancing Flame, San Francisco
  51. Program Code and Library by Jim Kent
  52. Documentation by Jim Kent and Heidi Brumbaugh
  53.  
  54.                        Turbo C FLI Library
  55.                         Table of Contents
  56.  
  57.  
  58.  
  59.  
  60.  
  61. 1. Introduction to the Turbo C FLI library. . . . . . . . . .   1
  62.  
  63. 2. Sample FLI programs. . . . . . . . . . . . . . . . . . . .   1
  64.      2.1 PLAY.C . . . . . . . . . . . . . . . . . . . . . . .   1
  65.      2.2 ALLFLIS.C. . . . . . . . . . . . . . . . . . . . . .   2
  66.      2.3 SLICEFLI.C . . . . . . . . . . . . . . . . . . . . .   3
  67.  
  68. 3. Usage of FLI routines. . . . . . . . . . . . . . . . . . .   5
  69.      3.1 Playback Routines. . . . . . . . . . . . . . . . . .   5
  70.      3.2 Save Routines. . . . . . . . . . . . . . . . . . . .   6
  71.  
  72. 4. VGA Graphics Support . . . . . . . . . . . . . . . . . . .   7
  73.  
  74. 5. MS-DOS Support . . . . . . . . . . . . . . . . . . . . . .   8
  75.  
  76. 6. The FLILIB header files. . . . . . . . . . . . . . . . . .  10
  77.      6.1 AAFLISAV.H . . . . . . . . . . . . . . . . . . . . .  10
  78.      6.2 AAFLI.H. . . . . . . . . . . . . . . . . . . . . . .  11
  79.      6.3 AATYPES.H  . . . . . . . . . . . . . . . . . . . . .  13
  80.      6.4 AADOS.H. . . . . . . . . . . . . . . . . . . . . . .  14
  81.      6.5 AAERR.H. . . . . . . . . . . . . . . . . . . . . . .  16
  82.      6.6 AASCREEN.H . . . . . . . . . . . . . . . . . . . . .  16
  83.  
  84. 8. Autodesk Animator files. . . . . . . . . . . . . . . . . .  18
  85.      8.1 Flic Files (.FLI). . . . . . . . . . . . . . . . . .  18
  86.      8.2 Picture Files (.GIF) . . . . . . . . . . . . . . . .  21
  87.      8.3 Cel Files (.CEL and .PIC). . . . . . . . . . . . . .  21
  88.      8.4 Palette Files (.COL) . . . . . . . . . . . . . . . .  22
  89.      8.5 Mask Files (.MSK). . . . . . . . . . . . . . . . . .  22
  90.      8.6 Text Files (.TXT). . . . . . . . . . . . . . . . . .  22
  91.      8.7 Font Files (.FNT). . . . . . . . . . . . . . . . . .  22
  92.      8.8 Polygon and Path files (.PLY). . . . . . . . . . . .  24
  93.      8.9 Optics Files (.OPT). . . . . . . . . . . . . . . . .  24
  94.      8.10 Record Files (.REC) . . . . . . . . . . . . . . . .  24
  95.  
  96.  
  97. 1. Introduction to the Turbo C FLI library
  98.  
  99.      FLI.LIB is a Turbo C large model library for manipulating 
  100. Autodesk Animator FLI files.  It also contains some general-
  101. purpose MS-DOS functions and a few VGA graphics primitives.
  102.  
  103.      The main Turbo C library is contained in the file FLI.LIB. 
  104. Additionally, you will need to include the header file AAFLI.H to
  105. read a FLI file and AAFLISAV.H to save a FLI file.  AAFLI.H will 
  106. include the additional files AATYPES.H, AADOS.H, AAERR.H and
  107. AASCREEN.H if they are not already included.  AAFLISAV.H will
  108. include AAFLI.H if it is not already included.
  109.  
  110.      The 58 source file routines to load or save a FLI are in the
  111. folder LIBSOURC; however, these modules are not necessary as they
  112. are already included in FLI.LIB.
  113.  
  114.      Your disk also includes three sample C files to load and
  115. play a FLI file.  The sample batch file which compiles these
  116. files in Turbo C is:
  117.  
  118. tcc -ml play.c fli.lib 
  119. tcc -ml allflis.c fli.lib 
  120. tcc -ml slicefli.c fli.lib
  121.  
  122.      In sum, the files you will need to use the Turbo C FLI
  123. library are:
  124.  
  125. AATYPES.H
  126. AADOS.H
  127. AAERR.H
  128. AASCREEN.H
  129. AAFLI.H
  130. AAFLISAV.H
  131. FLI.LIB
  132.  
  133. 2. Sample FLI programs
  134.  
  135.      Once the header files are included in your code and your
  136. make file is set up to properly link your program with the
  137. library, calling the high-level FLI routines is very
  138. straightforward.  In fact, the sample programs show that you can
  139. write a program to play back a FLI in about twenty-five lines --
  140. and most of that code is to verify that a VGA is connected!
  141.  
  142. 2.1 PLAY.C
  143.  
  144. This program will play a FLI file until a key is pressed.
  145.  
  146. #include "aafli.h" 
  147.  
  148. main(int argc, char *argv[]) 
  149. { 
  150. int ivmode; 
  151. Errval err; 
  152. if (argc != 2)   /* If command line looks wrong give a little help */
  153.  
  154.    { 
  155.    puts("Play will play a FLI file until a key is hit"); 
  156.    puts("Example usage: play pretty.fli"); 
  157.    } 
  158. else 
  159.    { 
  160.    ivmode = dos_get_vmode();  /* Get video mode to restore at exit */ 
  161.    dos_set_vmode(0x13);       /* Go into 320x200 256 color mode */ 
  162.    if (dos_get_vmode() == 0x13) 
  163.       { 
  164.       err = fli_play(argv[1]); 
  165.       dos_set_vmode(ivmode); 
  166.       if (err < AA_SUCCESS) 
  167.          puts(fli_error_message(err) ); 
  168.       } 
  169.    else 
  170.       puts("Not a VGA/MCGA display"); 
  171.    } 
  172. } 
  173.  
  174. 2.2 ALLFLIS.C
  175.  
  176. This program plays all the FLI files in the current directory
  177. once and exits.
  178.  
  179. #include "aafli.h" 
  180.  
  181. main() 
  182. { 
  183. Fndata *fn; 
  184. int ivmode; 
  185. Errval err; 
  186.  
  187. fn = dos_get_dta(); 
  188. if (dos_first("*.FLI", DOS_ATTR_NORMAL)) 
  189.    { 
  190.    ivmode = dos_get_vmode(); 
  191.    dos_set_vmode(0x13); 
  192.    if (dos_get_vmode() == 0x13) 
  193.       { 
  194.       for (;;) 
  195.          { 
  196.          if (dos_key_is()) /* check keyboard to abort between FLI's */
  197.             { 
  198.             dos_key_in(); 
  199.             break; 
  200.             } 
  201.          err = fli_once(fn->name); 
  202.          if (err < AA_SUCCESS) 
  203.             {  puts(fli_error_message(err)); 
  204.             } 
  205.          if (!dos_next()) 
  206.             break; 
  207.          } 
  208.       dos_set_vmode(ivmode); 
  209.       } 
  210.    else 
  211.       { 
  212.       puts("Not a VGA/MCGA display"); 
  213.       } 
  214.    } 
  215. else 
  216.    { 
  217.    puts("No .FLI files"); 
  218.    } 
  219. } 
  220.  
  221. 2.3 SLICEFLI.C
  222.  
  223. This program cuts out every other line of a FLI file, creating a
  224. new FLI.
  225.  
  226. #include "aaflisav.h" 
  227.  
  228. main(int argc, char *argv[]) 
  229. { 
  230. int i; 
  231. Errval err; 
  232. int ivmode; 
  233.  
  234. if (argc != 3) 
  235.    { 
  236.    puts("slicefli - a program to cut out every other line of a FLI.");
  237.    puts("   usage:  slicefli infile.fli outfile.fli"); 
  238.    exit(0); 
  239.    } 
  240. ivmode = dos_get_vmode(); 
  241. dos_set_vmode(0x13); /* To VGA/MCGA 320x200 256 color mode */ 
  242. if (dos_get_vmode() != 0x13) 
  243.    { 
  244.    puts("Not a VGA/MCGA display, sorry"); 
  245.    } 
  246. else 
  247.    { 
  248.    err = convert_fli(argv[1], argv[2]); 
  249.    if (err >= AA_SUCCESS) 
  250.       { 
  251.       fli_play(argv[2]); 
  252.       } 
  253.    dos_set_vmode(ivmode); 
  254.    if (err < AA_SUCCESS) puts(fli_error_message(err)); 
  255.    } 
  256. } 
  257.  
  258. /* zero out every other line of a screen */ 
  259. void slice_screen(Vscreen *s) 
  260. { 
  261. int i; 
  262. Pixel *p; 
  263.  
  264. p = s->p; 
  265. for (i=0; i<s->h; i+=2) 
  266.    { 
  267.    i86_bzero(p, s->bpr); 
  268.    p += 2*s->bpr; 
  269.    } 
  270. } 
  271.  
  272. Errval convert_fli(char *in, char *out) 
  273. { 
  274. Errval err = AA_SUCCESS;   /* start out optimistic! */ 
  275. Vscreen *bs; 
  276. Fli_head inhead, outhead; 
  277. Jfile infile = 0, outfile = 0; 
  278. int i; 
  279.  
  280. if ((bs = aa_alloc_mem_screen()) == NULL) 
  281.    { 
  282.    err = AA_ERR_NOMEM; 
  283.    goto EXIT; 
  284.    } 
  285. if ((infile = fli_open(in, &inhead)) < 0) 
  286.    { 
  287.    err = infile; 
  288.    goto EXIT; 
  289.    } 
  290. if ((outfile = fli_create(out, &outhead, inhead.speed)) < AA_SUCCESS) 
  291.    { 
  292.    goto EXIT; 
  293.    } 
  294. for (i=0; i<inhead.frame_count; i++) 
  295.    { 
  296.    aa_copy_screen(&aa_screen, bs); 
  297.    if ((err = fli_next_frame(infile)) < AA_SUCCESS) 
  298.       { 
  299.       goto EXIT; 
  300.       } 
  301.    slice_screen(&aa_screen); 
  302.    if ((err = fli_write_next(outfile, &outhead, &aa_screen, bs)) <
  303. AA_SUCCESS) 
  304.       { 
  305.       goto EXIT;  } 
  306.    } 
  307. if ((err = fli_end(outfile, &outhead, &aa_screen, bs)) < AA_SUCCESS) 
  308.    { 
  309.    goto EXIT; 
  310.    } 
  311. EXIT: 
  312. if (infile != 0) 
  313.    dos_close (infile); 
  314. if (outfile != 0) 
  315.    dos_close (outfile); 
  316. aa_free_mem_screen(bs); 
  317. if (err < AA_SUCCESS) 
  318.    { 
  319.    dos_delete (out); 
  320.    } 
  321. return(err); 
  322. } 
  323.  
  324. 3. Usage of FLI routines
  325.  
  326. 3.1 Playback Routines
  327.  
  328.      These are the main routines you will need to use to play
  329. back a FLI animation.  Note that you do not need to call some of
  330. the routines directly if you use only the high-level routines. 
  331. See the sample programs above for details.
  332.  
  333. Play a FLI on VGA screen until a key is hit. 
  334.    Errval fli_play(char *fliname) 
  335.  
  336. Play a FLI through once on VGA screen. 
  337.    Errval fli_once(char *fliname) 
  338.  
  339. Open up a FLI file, read in it's header, and check magic values
  340. to verify that it is a FLI file.  Returns open file handle on
  341. success, a negative error code on failure. 
  342.    Jfile fli_open(char *fliname, Fli_head *fh) 
  343.  
  344. Read next frame of file and update VGA screen. 
  345.    Errval fli_next_frame(Jfile ff) 
  346.  
  347. Update a screen with the next frame of a FLI file.  Note that
  348. fli_read_display_frame(ff, &aa_screen, TRUE) is the same thing as
  349. fli_next_frame(ff). 
  350.    Errval fli_read_display_frame( 
  351.       Jfile ff,            /* File handle */ 
  352.       Vscreen *v,          /* Screen to update */ 
  353.       Boolean see_colors)  /* Update hardware color registers? */ 
  354.  
  355. This routine decompresses from memory onto a screen. Use if you
  356. want to play FLI's from RAM rather than off the disk. 
  357.    void fli_uncomp( 
  358.       Vscreen *v,          /* Screen to update */ 
  359.       Fli_frame *frame,    /* Header for this frame */   
  360.       Cbuf *cbuf,          /* Compressed data for this frame */ 
  361.       Boolean see_colors)  /* Update hardware color registers? */ 
  362.  
  363. This plays a FLI from disk until the user-supplied function
  364. returns false.  The 'until' function is called every frame at
  365. least once, and as many times as possible until it's time for the
  366. next frame.  See fli_until_finished and fli_until_key. 
  367.    Errval fli_until( 
  368.       char *fliname,       /* Name of FLI to play */ 
  369.       int speed,           /* Speed to play.  If negative uses speed
  370.                            in file */ 
  371.       Boolean (*until)())  /* User-supplied function.  (See below.) */
  372.  
  373. This function returns (cur_frame < frame_count).  It's used to
  374. implement fli_once(). 
  375.    Boolean fli_until_finished( 
  376.       int cur_frame,       /* How many frames we've played */ 
  377.       int frame_count,     /* Number of frames in this FLI */ 
  378.       int cur_loop)        /* How many times have played FLI so far */
  379.  
  380. This function ignores all it's arguments, and returns FALSE only
  381. if a key is hit.  Used to implement fli_play(). 
  382.    Boolean fli_until_key( 
  383.       int cur_frame,       /* How many frames we've played */ 
  384.       int frame_count,     /* Number of frames in this FLI */ 
  385.       int cur_loop)        /* How many times have played FLI so far */
  386.  
  387. Return a descriptive name for the error code. 
  388.    char *fli_error_message(Errval err) 
  389.  
  390.  
  391. 3.2 Save Routines
  392.  
  393.      The following routines are used to save a FLI file to disk.
  394.  
  395. Start writing a FLI file.  Open file and initialize Fli_head
  396. structure. Returns file handle if everything is ok, a negative
  397. error code if not. 
  398.    Jfile fli_create( 
  399.       char *fliname,       /* Name for new FLI file */ 
  400.       Fli_head *fh,        /* Non-initialized fli-header */ 
  401.       int speed)           /* Speed (in 1/70th of a second) of FLI */ 
  402.  
  403. Write next frame to FLI file.  On first frame the value in 'last'
  404. is ignored. 
  405.    Errval fli_write_next( 
  406.       Jfile ff,            /* FLI file returned by fli_create */
  407.       Fli_head *fh,        /* Same header used by fli_create */
  408.       Vscreen *this,       /* Current frame */ 
  409.       Vscreen *last)       /* Previous frame */ 
  410.  
  411. Close FLI up:  calculate and write the ring frame, that is the
  412. difference between the first and last frame of a FLI.  Rewrite fh
  413. at start of file with final frame and byte counts.  Firstf_buf
  414. will be  loaded with the  first frame of the FLI as a side
  415. effect. 
  416.    Errval fli_end( 
  417.       Jfile ff,            /* FLI file handle */ 
  418.       Fli_head *fh,        /* Header as initialized by fli_create */ 
  419.       Vscreen *end_frame,  /* The final frame in the animation */ 
  420.       Vscreen *firstf_buf) /* A full screen buffer for 1st frame */ 
  421.  
  422. Compress a frame into comp_buf and return size after compression. 
  423. Types should be FLI_BRUN for  first frame and  FLI_LCCOMP for
  424. later frames (see AAFLI.H).  If you use fli_create,
  425. fli_write_next, and fli_end to create your  FLI files, you won't
  426. need to call this.
  427. long fli_comp_frame( 
  428.    Cbuf *comp_buf,         /* Buffer--should be CBUF_SIZE or bigger */
  429.    Pixel *last_screen,     /* Pixels from previous frame */ 
  430.    Cmap *last_cmap,        /* Colors from previous frame */ 
  431.    Pixel *this_screen,     /* Pixels from current frame */ 
  432.    Cmap *this_cmap,        /* Colors from previous frame. */ 
  433.    int type);              /* FLI_BRUN, FLI_LCCOMP etc. */  
  434.  
  435.  
  436. 4. VGA Graphics Support
  437.  
  438.      Most of these are lower-level routines you won't need to
  439. call directly; however, they are included in the library and
  440. supported here.
  441.  
  442. Sets up a 320x200 screen in memory that is structured the same as
  443. the VGA Mode 0x13. (The Vscreen structure is in AASCREEN.H.) 
  444.    Vscreen *aa_alloc_mem_screen() 
  445.  
  446. Set all pixels in screen to zero. 
  447.    void aa_clear_screen(Vscreen *s) 
  448.  
  449. Software echo of color map associated with aa_screen, the Vscreen
  450. for the VGA. 
  451.    Cmap aa_colors[256*3] 
  452. Copy the pixels and color maps from one screen to another.
  453. (Doesn't update VGA hardware registers.  Use aa_set_colors(0,
  454. 256, dest->cmap) to do that.) 
  455.    void aa_copy_screen(Vscreen *source, Vscreen *dest) 
  456.  
  457. Does nothing but call C library free(pt).  Used by all flilib
  458. functions to free aa_malloc()'d memory.   If you need to manage
  459. your own memory override these two symbols with your own. 
  460.    void aa_free(void *pt) 
  461.  
  462. Frees up memory screen gotten with aa_alloc_mem_screen(). Will
  463. check 's' for NULL before calling aa_free. 
  464.    void aa_free_mem_screen(Vscreen *s) 
  465.  
  466. Returns a AACLOCK_HZ frequency clock.  (AACLOCK_HZ is defined in
  467. AACLOCK.H as 4608 currently, but this may change. The clock
  468. management part of library is still unstable.) You must call
  469. aa_goclock() before calling this. 
  470.    long aa_getclock() 
  471.  
  472. Initialize clock. 
  473.    long aa_goclock() 
  474.  
  475. Does nothing but call C library malloc(size). See aa_free(). 
  476.    void *aa_malloc(unsigned size) 
  477.  
  478. A Vscreen structure refering to the VGA pixel memory. Useful as
  479. an argument to the many flilib functions that work on a Vscreen. 
  480.    Vscreen aa_screen 
  481.  
  482. Set some VGA color map entries from a memory table. Table is
  483. three bytes per color, one byte each for  each red, green, blue
  484. component.  The value of an rgb component should be from 0 to 63.
  485.    void aa_set_colors(int start_ix, int count, Cmap *table) 
  486.  
  487. Return when VGA is out of vertical blank. 
  488.    void aa_wait_no_vblank() 
  489.  
  490. Return when VGA is in vertical blank. 
  491.    void aa_wait_vblank() 
  492.  
  493. 5. MS-DOS Support 
  494.  
  495.      These are some general-purpose DOS routines.
  496.  
  497. That Jfile is typedef'd as an int in AADOS.H. Close a file opened
  498. with dos_open or dos_create. 
  499.    void dos_close(Jfile file) 
  500.  
  501. Tries to delete file. Returns TRUE (1) on success, FALSE (0) on
  502. failure. 
  503.    Boolean dos_delete(char *file_name) 
  504. Returns TRUE if file exists. 
  505.    Boolean dos_exists(char *file_name) 
  506.  
  507. Pattern is typically something of the form "*.FLI" and attribute
  508. DOS_ATTR_NORMAL as defined in AADOS.H.  This will return TRUE if
  509. there is a file matching the wildcard pattern and put the name of
  510. this file in the data transfer area (see dos_get_dta below).
  511.    Boolean dos_first(char *pattern, int attribute) 
  512.  
  513. Gets data transfer area from DOS for directory searches. See
  514. dos_first() and dos_next(). 
  515.    Fndata dos_get_dta(void) 
  516.  
  517. Returns current display mode. 
  518.    int dos_get_vmode() 
  519.  
  520. Returns a 16-bit keyboard scan code.  Lower 8 bits are usually
  521. ASCII values, or zero if it's a special key such as the cursor
  522. arrows. 
  523.    int dos_key_in() 
  524.  
  525. Returns TRUE if a key is ready to be read from keyboard.
  526.    Boolean dos_key_is() 
  527.  
  528. Returns a value with bits for the Shift/Alt/Control keys.
  529.    int dos_key_shift() 
  530.  
  531. Tries to make a new directory. 
  532.    Boolean dos_make_dir(char *dir_name) 
  533.  
  534. Fetches next filename matching wildcard set up by dos_first()
  535. into the data transfer area.  Returns FALSE if there are no more
  536. matches. 
  537.    Boolean dos_next() 
  538.  
  539. Tries to open a file from MS-DOS.  Returns zero if can't open
  540. file.  (Not negative as standard.) See AADOS.H for definitions of
  541. JREAD_ONLY, etc. for mode.
  542.    Jfile dos_open(char *filename, int mode) 
  543.  
  544. Read from file into memory buffer.  Note that size can be larger
  545. than 64K. 
  546.    long dos_read(Jfile file, void *buf, long size) 
  547.  
  548. Rename a file.  Return success. 
  549.    Boolean dos_rename(char *oldname, char *newname) 
  550.  
  551. This is used to implement dos_read() and dos_write() macros.
  552. Should not be called directly. 
  553.    long dos_rw(...) 
  554. Write from memory buffer into file.  Note that size can be larger
  555. than 64K. 
  556.    long dos_write(Jfile file, void *buf, long size) 
  557.  
  558. See AADOS.H for definitions of JSEEK_START etc. for mode.
  559.    long dos_seek(Jfile file, long offset, int mode) 
  560.  
  561. Set display mode.  0x13 for 256 color 320x200. 
  562.    void dos_set_vmode(int mode) 
  563.  
  564. Returns file position in bytes from beginning. 
  565.    long dos_tell(Jfile file) 
  566.  
  567.  
  568. 6. The FLILIB header files
  569.  
  570.      Following are the constants, structures and variables used
  571. in the header files you will need to play back and save a FLI
  572. file.
  573.  
  574. 6.1 AAFLISAV.H
  575.  
  576. #ifndef AAFLISAV_H 
  577. #define AAFLISAV_H 
  578.  
  579. #ifndef AAFLI_H 
  580. #include "aafli.h" 
  581. #endif /* AAFLI_H */ 
  582.  
  583. /* Compress a frame into a RAM buffer.  Return size of frame. */ 
  584. long fli_comp_frame(Cbuf *comp_buf,       /* Buffer FLI_CBUF_SIZE or
  585.                                           bigger */ 
  586.    Pixel *last_screen, Cmap *last_cmap,   /*Data from previous frame*/
  587.    Pixel *this_screen, Cmap *this_cmap,   /* Data for this frame */ 
  588.    int type);                             /* FLI_BRUN?  FLI_LC? */ 
  589.  
  590. /* Open FLI file and write out first frame.  Return file handle if
  591. things go well, error code otherwise. */ 
  592. Jfile fli_create(char *fliname,  /* file name */ 
  593.    Fli_head *fh,                 /* fli_create will initialize this */
  594.    int speed);                   /* Speed in 1/70th of a second */ 
  595.  
  596. /* Write succeeding frames of a FLI. */ 
  597. Errval fli_write_next(Jfile ff,  /* FLI file returned by fli_create */
  598.    Fli_head *fh,                 /* Same header used by fli_create */ 
  599.    Vscreen *this,                /* Current frame */ 
  600.    Vscreen *last);               /* Previous frame */ 
  601.  
  602. /* Finish up writing a FLI file. Write the 'ring frame', which is the
  603. difference between the first and last frame of a FLI.  Pass in the
  604. final frame of the FLI in last_frame.  firstf_buf will be loaded with
  605. the first frame of the FLI as a side effect.  */   Errval fli_end(Jfile ff, Fli_head *fh,  
  606.    Vscreen *end_frame, Vscreen *firstf_buf); 
  607.  
  608. #endif /* AAFLISAV_H */ 
  609.  
  610. 6.2 AAFLI.H
  611.  
  612. #ifndef AAFLI_H 
  613. #define AAFLI_H 
  614.  
  615. #ifndef AATYPES_H 
  616. #include "aatypes.h" 
  617. #endif /* AATYPES_H */ 
  618.  
  619. #ifndef AADOS_H 
  620. #include "aados.h" 
  621. #endif /* AADOS_H */ 
  622.  
  623. #ifndef AAERR_H 
  624. #include "aaerr.h" 
  625. #endif /* AAERR_H */ 
  626.  
  627. #ifndef AASCREEN_H 
  628. #include "aascreen.h" 
  629. #endif /* AASCREEN_H */ 
  630.  
  631. #define FLI_MAXFRAMES (4*1000)   /* Max number of frames. */ 
  632. #define FLIH_MAGIC 0xaf11        /* Fileheader Magic */ 
  633. #define FLIF_MAGIC 0xf1fa        /* Frame Magic */ 
  634.  
  635. typedef struct fli_head 
  636.    { 
  637.    long size; 
  638.    USHORT type;                  /* = FLIH_MAGIC */ 
  639.    USHORT frame_count; 
  640.    USHORT width; 
  641.    USHORT height; 
  642.    USHORT bits_a_pixel; 
  643.    SHORT flags; 
  644.    SHORT speed; 
  645.    long next_head; 
  646.    long frames_in_table; 
  647.    SHORT file;          /* Used by players.  Contains 0's on disk. */ 
  648.    long frame1_off;     /* Used by players.  Contains 0's on disk. */ 
  649.    long strokes;        /* how many paint strokes etc. made. */ 
  650.    long session;        /* strokes since file's been loaded. */ 
  651.    char reserved[88];   /* all zeroes on disk */ 
  652.    } Fli_head; 
  653.  
  654. /* bit defines for flags field */ 
  655. #define FLI_FINISHED 1  /* finished writing fli */ 
  656. #define FLI_LOOPED   2  /* fli has a loop frame */   
  657. typedef struct fli_frame 
  658.    { 
  659.    long size; 
  660.    USHORT type;      /* FLIF_MAGIC */ 
  661.    SHORT chunks; 
  662.    char pad[8]; 
  663.    } Fli_frame; 
  664.  
  665. typedef struct fli_chunk 
  666.    { 
  667.    long size; 
  668.    SHORT type; 
  669.    } Fli_chunk; 
  670.  
  671. typedef UBYTE Cbuf;     /* compression buffer */ 
  672.  
  673. /* size of buffer big enough to hold worst case FLI frame */ 
  674. #define FLI_CBUF_SIZE
  675. (64000L+3*AA_COLORS+2*sizeof(Fli_chunk)+sizeof(Fli_frame)) 
  676.  
  677. /* types of chunk in a fli_frame */ 
  678. #define FLI_COLOR 11 
  679. #define FLI_LC 12 
  680. #define FLI_BLACK 13 
  681. #define FLI_BRUN 15 
  682. #define FLI_COPY 16 
  683.  
  684. /** Higher-level FLI playing functions **/ 
  685. /* Decompress a single frame that's in RAM */ 
  686. void fli_uncomp(Vscreen *f,   /* The screen to update */ 
  687.    Fli_frame *frame,          /* Header for this frame */ 
  688.    Cbuf *cbuf,                /* Compressed data for this frame */
  689.    Boolean see_colors);       /* update the hardware color map? */ 
  690.  
  691. /* Read in FLI header, verify that it's a FLI file and return handle.
  692. See AAERR.H for negative return values if there are problems. */ 
  693. Jfile fli_open(char *fliname, Fli_head *fh); 
  694.  
  695. /* Read in next frame and uncompress onto screen, optionally updating
  696. hardware color palette */ 
  697. Errval fli_read_display_frame(Jfile ff, Vscreen *v, Boolean
  698. see_colors); 
  699.  
  700. /* Read and display next frame onto VGA display */ 
  701. Errval fli_next_frame(Jfile ff); 
  702.  
  703. /* Play FLI, going on forever or until 'until' function returns FALSE. 
  704. until is called with the current frame, the total frame in the FLI,
  705. and how many times have played entire FLI. */ 
  706. Errval fli_until(char *fliname, /* name of FLI to play */ 
  707.    int speed,              /* if speed negative, use speed in file */ 
  708.    AAivec until);          /* function to call to see when to stop */ 
  709.  
  710. /* The 'until' function we use to construct fli_play */ 
  711. Boolean fli_until_key(int cur_frame, int frame_count, int cur_loop); 
  712.  
  713. /* Play FLI looping forever until any key is hit */ 
  714. Errval fli_play(char *fliname); 
  715.  
  716. /* Play FLI once */ 
  717. Errval fli_once(char *fliname); 
  718.  
  719. #endif /* AAFLI_H */ 
  720.  
  721. 6.3 AATYPES.H 
  722.  
  723. #ifndef AATYPES_H 
  724. #define AATYPES_H 
  725.  
  726. #ifndef NULL 
  727. #define NULL ((void *)0L) 
  728. #endif /* NULL */ 
  729.  
  730. void *aa_malloc(unsigned); /* heap allocator */ 
  731. void aa_free(void *);      /* heap free'er */ 
  732.  
  733. #ifndef UBYTE 
  734. #define UBYTE unsigned char 
  735. #endif /* UBYTE */ 
  736. #ifndef BYTE 
  737. #define BYTE signed char 
  738. #endif /* BYTE */ 
  739. #ifndef SHORT 
  740. #define SHORT short 
  741. #endif /* SHORT */ 
  742. #ifndef SHORT 
  743. #define SHORT short 
  744. #endif /* SHORT */ 
  745. #ifndef USHORT  
  746. #define USHORT unsigned short 
  747. #endif /* USHORT */ 
  748. #ifndef LONG 
  749. #define LONG long 
  750. #endif /* LONG */ 
  751. #ifndef ULONG 
  752. #define ULONG unsigned long 
  753. #endif /* ULONG */ 
  754.  
  755. typedef void (*AAvec)();   /* pointer to a void-valued function */ 
  756. typedef int (*AAivec)();   /* pointer to an integer valued function */
  757. typedef int Boolean;      /* functions explicitly returning 0 or 1 */
  758. #define TRUE 1 
  759. #define FALSE 0 
  760.  
  761. /* useful macro to count elements in an array */ 
  762. #define Array_els(arr) (sizeof(arr)/sizeof(arr[0])) 
  763.  
  764. #endif /* AATYPES_H */ 
  765.  
  766. 6.4 AADOS.H
  767.  
  768. #ifndef AADOS_H 
  769. #define AADOS_H 
  770.  
  771. #ifndef AATYPES_H 
  772. #include "aatypes.h" 
  773. #endif /* AATYPES_H */ 
  774.  
  775. typedef int Jfile; 
  776.  
  777. dos_key_is(void);  /* return 1 if a key is ready to read, 0 if not */ 
  778. dos_key_in(void);  /* return next keyboard input.  Wait for it. */ 
  779.  
  780. /* open a file that already exists.*/ 
  781. Jfile dos_open(char *title, int mode); 
  782.  
  783. /* defines for mode parameter to dos_open  */ 
  784. #define DOS_READ_ONLY 0 
  785. #define DOS_WRITE_ONLY 1 
  786. #define DOS_READ_WRITE 2 
  787.  
  788. Jfile dos_create(char *title);   /* Create a new read/write file */ 
  789. void dos_close(Jfile f);         /* close file */ 
  790.  
  791. /* File read/write. Normally go through macros rather than use this
  792. function. */
  793. long dos_rw(Jfile f,void *buf,long size,int ah); 
  794. #define dos_read(f,b,size) dos_rw(f,b,size,0x3f) 
  795. #define dos_write(f,b,size) dos_rw(f,b,size,0x40) 
  796.  
  797. long dos_seek (Jfile f, long offset, int mode); 
  798. long dos_tell (Jfile f); 
  799.  
  800. /* defines for mode parameter to dos_seek  */ 
  801. #define DOS_SEEK_START  0 
  802. #define DOS_SEEK_RELATIVE  1 
  803. #define DOS_SEEK_END 2 
  804.  
  805. /* size of a buffer long enough to hold any MS-DOS path */ 
  806. #define DOS_PATH_SIZE 80 
  807. /* this is the data structure used by dos_first() and dos_next () in
  808. searching directories */ 
  809. typedef struct fndata  
  810.    { 
  811.    char reserved[21]; 
  812.    char attribute; 
  813.    USHORT time, date; 
  814.    long size; 
  815.    char name[13]; 
  816.    char fordos[128-43]; 
  817.    } Fndata; 
  818.  
  819. Fndata *dos_get_dta (void); /* get the DTA for directory search */ 
  820.  
  821. Boolean dos_first(char *pattern, int attributes); 
  822.  
  823. /* defines for attributes parameters */ 
  824. #define DOS_ATTR_DIR 16 
  825. #define DOS_ATTR_NORMAL  0 
  826. Boolean dos_next (void); 
  827.   
  828. /* This gets rid of the MS-DOS abort/retry/fail message. Afterwards
  829. MS-DOS acts like it was always a fail. dos_get_devlist () calls     
  830. this. */ 
  831. void dos_no_abort_retry_cancel (void);  
  832.  
  833. /* Changes device and directory. For example, name could be
  834. C:\VPAINT\FISHIES */ 
  835. Boolean dos_change_dir(char *name); 
  836.  
  837. /* Tell DOS it's time to go to another drive number.  0 = A:, 1 = B:,
  838. etc. */ 
  839. Boolean dos_change_dev(int newdev); 
  840.  
  841. /* Get current drive. 0 = A:, etc. */ 
  842. int dos_get_dev (void); 
  843.  
  844. /* Get the current device and directory into path */ 
  845. Boolean dos_get_dir (char path[DOS_PATH_SIZE]); 
  846.  
  847. /* Create a directory.  (Don't include device info.  If needed do a
  848. dos_change_dev(dev) first.) */ 
  849. Boolean dos_make_dir(char *name); 
  850.  
  851. /* Figure how much free space is on a device.  0 = current device. 1 =
  852. A:, etc. */ 
  853. long dos_dfree(int dev); 
  854.  
  855. #endif /* AADOS_H */ 
  856.  
  857. 6.5 AAERR.H
  858.  
  859. #ifndef AAERR_H 
  860. #define AAERR_H 
  861.  
  862. #define AA_SUCCESS 0             /* No Problem! */ 
  863. #define AA_ERR_MISC -1           /* Unclassified error */ 
  864. #define AA_ERR_NOMEM -2          /* Not enough memory */ 
  865. #define AA_ERR_CANTFIND -3       /* File doesn't exist */ 
  866. #define AA_ERR_CANTMAKE -4       /* Can't create file */ 
  867. #define AA_ERR_BADTYPE -5        /* File is not the right type */ 
  868. #define AA_ERR_BADDATA -6        /* File damaged internally */ 
  869. #define AA_ERR_WRONGREZ -7       /* File isn't 320x200 */ 
  870. #define AA_ERR_SHORTREAD -8      /* Not all of file is there */ 
  871. #define AA_ERR_SHORTWRITE -9     /* Couldn't write all of file */ 
  872. #define AA_ERR_SEEK  -10         /* Error during file seek */ 
  873.  
  874. typedef int Errval;   
  875. /* return something to say about error */ 
  876. char *fli_error_message(Errval err); 
  877.  
  878. #endif /* AAERR_H */ 
  879.  
  880. 6.6 AASCREEN.H
  881.  
  882. #ifndef AASCREEN_H 
  883. #define AASCREEN_H 
  884.  
  885. #ifndef AATYPES_H 
  886. #include "aatypes.h" 
  887. #endif /* AATYPES_H */ 
  888.  
  889. /* Graphics types */ 
  890. typedef unsigned char Cmap; 
  891. typedef unsigned char Pixel; 
  892. typedef unsigned char Bitplane; 
  893.  
  894. /* Constants pertaining to 320x200 256 color mode mostly */ 
  895. #define AA_VGA_SCREEN ((Pixel *)0xa0000000) 
  896. #define AA_XMAX 320 
  897. #define AA_YMAX 200 
  898. #define AA_BPR 320 
  899. #define AA_COLORS 256 
  900.  
  901. /* This structure is something we can draw on. */ 
  902. struct vscreen 
  903.    { 
  904.    int x, y;         /* upper left corner in screen coordinates */ 
  905.    unsigned w, h;    /* width, height */ 
  906.    unsigned bpr;     /* bytes per row of image p */ 
  907.    Pixel *p;         /* Starts on segment boundary */ 
  908.    Cmap *cmap;  long psize;/* size of pixels */ 
  909.    Pixel *allocedp;  /* for memory based screens only */ 
  910.    }; 
  911. typedef struct vscreen Vscreen; 
  912. extern Vscreen aa_screen; 
  913. extern Cmap aa_colors[];            /* software echo of color map */ 
  914. Boolean aa_open_vga_screen(void);   /* opens 256 color screen */ 
  915. void aa_close_vga_screen(void); 
  916.  
  917. /* Open a screen you can draw on but not see */ 
  918. Vscreen *aa_alloc_mem_screen(void); 
  919. void aa_free_mem_screen(Vscreen *ms);  /* dispose of memory screen */ 
  920. void aa_copy_screen(Vscreen *source, Vscreen *dest); 
  921. void aa_clear_screen(Vscreen *vs); 
  922.  
  923. /* Get the current video mode */ 
  924. int dos_get_vmode(void); 
  925. /* Set video mode.  Mode 0x13 is 320x200 256 color */ 
  926. void dos_set_vmode(int mode); 
  927. /* Set the VGA color map. */ 
  928. void aa_set_colors(int start, int count, Cmap *cmap);  
  929. /* Wait until in vertical blank */ 
  930. void aa_wait_vblank(void); 
  931. /* Wait until out of vertical blank */ 
  932. void aa_wait_no_vblank(void); 
  933.  
  934. #endif /* AASCREEN_H */ 
  935.  
  936.  
  937. 7. Reserved Routine Names
  938.  
  939.    What follows is a summary of low-level routines which you
  940. should not call directly as they are subject to future
  941. modification.  They are listed here only to prevent you from
  942. inadvertently duplicating the names elsewhere in your own code.
  943.  
  944.     fii_brun 
  945.     fii_fccomp 
  946.     fii_lccomp 
  947.     fii_mem_fcuncomp 
  948.     fii_reg_fcuncomp 
  949.     fii_tnsame 
  950.     fii_tnskip 
  951.     fii_unbrun 
  952.     fii_unlccomp 
  953.  
  954.     i86_bcompare 
  955.     i86_bcontrast 
  956.     i86_bcopy 
  957.     i86_bsame 
  958.     i86_bzero 
  959.     i86_enorm_ptr      i86_even_copy 
  960.     i86_make_long 
  961.     i86_make_ptr 
  962.     i86_norm_ptr 
  963.     i86_ptr_offset 
  964.     i86_ptr_seg 
  965.     i86_ptr_to_long 
  966.     i86_sysint 
  967.     i86_wcompare 
  968.     i86_wcontrast 
  969.     i86_wcopy 
  970.     i86_wsame 
  971.     i86_wzero 
  972.  
  973. 8. Autodesk Animator files
  974.  
  975.      Following is a detailed description of the FLI file format,
  976. as well as the formats for Autodesk Animator's other main file
  977. types.
  978.  
  979. 8.1 Flic Files (.FLI)
  980.  
  981.      The details of a FLI file are moderately complex, but the
  982. idea behind it is simple: don't bother storing the parts of a
  983. frame that are the same as the last frame.  Not only does this
  984. save space, but it's very quick.  It's faster to leave a pixel
  985. alone than to set it.
  986.  
  987.      A FLI file has a 128-byte header followed by a sequence of
  988. frames. The first frame is compressed using a bytewise run-length
  989. compression scheme.  Subsequent frames are stored as the
  990. difference from the previous frame.  (Occasionally the first
  991. frame and/or subsequent frames are uncompressed.)  There is one
  992. extra frame at the end of a FLI which contains the difference
  993. between the last frame and the first frame.
  994.  
  995.      The FLI header:
  996.  
  997.      byte size name      meaning
  998.      offset
  999.  
  1000.      0    4    size      Length of file, for programs that want
  1001.                          to read the FLI all at once if possible.
  1002.      4    2    magic     Set to hex AF11.  Please use another
  1003.                          value here if you change format (even to
  1004.                          a different resolution) so Autodesk
  1005.                          Animator won't crash trying to read it.
  1006.      6    2    frames    Number of frames in FLI.  FLI files have
  1007.                          a maxium length of 4000 frames.
  1008.      8    2    width     Screen width (320).
  1009.      10   2    height    Screen height (200).
  1010.      12   2    depth     Depth of a pixel (8). 142flagsMust be 0.
  1011.      16   2    speed     Number of video ticks between frames.
  1012.      18   4    next      Set to 0.
  1013.      22   4    frit      Set to 0.
  1014.      26   102  expand    All zeroes -- for future enhancement.
  1015.  
  1016.      Next are the frames, each of which has a header:
  1017.  
  1018.      byte size name      meaning
  1019.      offset
  1020.      0    4    size      Bytes in this frame.  Autodesk Animator
  1021.                          demands that this be less than 64K.
  1022.      4    2    magic     Always hexadecimal F1FA
  1023.      6    2    chunks    Number of 'chunks' in frame.
  1024.      8    8    expand    Space for future enhancements.  All
  1025.                          zeros.
  1026.  
  1027.      After the frame header come the chunks that make up the
  1028. frame.  First comes a color chunk if the color map has changed
  1029. from the last frame.  Then comes a pixel chunk if the pixels have
  1030. changed.  If the frame is absolutely identical to the last frame
  1031. there will be no chunks at all.
  1032.  
  1033.      A chunk itself has a header, followed by the data.  The
  1034. chunk header is:
  1035.  
  1036.      byte size name meaning
  1037.      offset
  1038.      0    4    size Bytes in this chunk.
  1039.      4    2    type Type of chunk (see below).
  1040.  
  1041.      There are currently five types of chunks you'll see in a FLI
  1042. file.
  1043.  
  1044.      number    name      meaning
  1045.      11        FLI_COLOR Compressed color map
  1046.      12        FLI_LC    Line compressed -- the most common type
  1047.                          of compression for any but the first
  1048.                          frame.  Describes the pixel difference
  1049.                          from the previous frame.
  1050.      13        FLI_BLACK Set whole screen to color 0 (only occurs
  1051.                          on the first frame).
  1052.      15        FLI_BRUN  Bytewise run-length compression -- first
  1053.                          frame only
  1054.      16        FLI_COPY  Indicates uncompressed 64000 bytes soon
  1055.                          to follow.  For those times when
  1056.                          compression just doesn't work!
  1057.  
  1058.      The compression schemes are all byte-oriented.  If the
  1059. compressed data ends up being an odd length a single pad byte is
  1060. inserted so that the FLI_COPY's always start at an even address
  1061. for faster DMA.
  1062. FLI_COLOR Chunks
  1063.      The first word is the number of packets in this chunk. This
  1064. is followed directly by the packets.  The first byte of a packet
  1065. says how many colors to skip.  The next byte says how many colors
  1066. to change.  If this byte is zero it is interpreted to mean 256. 
  1067. Next follows 3 bytes for each color to change (one each for red,
  1068. green and blue).
  1069.  
  1070. FLI_LC Chunks
  1071.      This is the most common, and alas, most complex chunk.   The
  1072. first word (16 bits) is the number of lines starting from the top
  1073. of the screen that are the same as the previous frame. (For
  1074. example, if there is motion only on the bottom line of screen
  1075. you'd have a 199 here.)  The next word is the number of lines
  1076. that do change.  Next there is the data for the changing lines
  1077. themselves.  Each line is compressed individually; among other
  1078. things this makes it much easier to play back the FLI at a
  1079. reduced size.
  1080.  
  1081.      The first byte of a compressed line is the number of packets
  1082. in this line.  If the line is unchanged from the last frame this 
  1083. is zero.  The format of an individual packet is:
  1084.  
  1085. skip_count
  1086. size_count
  1087. data
  1088.  
  1089.      The skip count is a single byte.  If more than 255 pixels
  1090. are to be skipped it must be broken into 2 packets. The size
  1091. count is also a byte.  If it is positive, that many bytes of data
  1092. follow and are to be copied to the screen.  If it's negative a
  1093. single byte follows, and is repeated -skip_count times.
  1094.  
  1095.      In the worst case a FLI_LC frame can be about 70K.  If it
  1096. comes out to be 60000 bytes or more Autodesk Animator decides
  1097. compression isn't worthwhile and saves the frame as FLI_COPY.
  1098.  
  1099. FLI_BLACK Chunks
  1100.      These are very simple.  There is no data associated with
  1101. them at all. In fact they are only generated for the first frame
  1102. in Autodesk Animator after the user selects NEW under the FLIC
  1103. menu.
  1104.  
  1105. FLI_BRUN Chunks
  1106.      These are much like FLI_LC chunks without the skips.  They
  1107. start immediately with the data for the first line, and go line-
  1108. by-line from there.  The first byte contains the number of
  1109. packets in that line.  The format for a packet is:
  1110.  
  1111. size_count
  1112. data
  1113.      If size_count is positive the data consists of a single byte
  1114. which is repeated size_count times. If size_count is negative
  1115. there are -size_count bytes of data which are copied to the
  1116. screen. In Autodesk Animator if the "compressed" data shows signs
  1117. of exceeding 60000 bytes the frame is stored as FLI_COPY instead.
  1118.  
  1119. FLI_COPY Chunks
  1120.      These are 64000 bytes of data for direct reading onto the
  1121. screen.
  1122.  
  1123. 8.2 Picture Files (.GIF)
  1124.  
  1125.      GIF (Graphics Interchange Format) is a format developed by
  1126. CompuServe Information Services.  GIF files are as close to
  1127. computer- and resolution-independent as we're likely to see in
  1128. the next few years -- there are GIF viewers available for the
  1129. Amiga, the Atari ST and 8-bit line, the Tandy Color Computer, the
  1130. Apple II, the MacIntosh, Sun workstations, PC compatibles and
  1131. most other computers with any sort of graphics display at all. 
  1132. There are also programs to convert from the more "native" file
  1133. formats (such as DEGAS on the ST, IFF on the Amiga, and MacPaint
  1134. on the Mac) to GIF.  Many of these conversion programs are
  1135. available free on Compuserve.
  1136.  
  1137.      GIF files are also fairly densely compressed, using a
  1138. modified Lempel-Zif-Welch "ladder" compression scheme similar to
  1139. that used in the popular archive programs ARC and PKZIP.  
  1140.  
  1141.      Unfortunately the nitty-gritty details of what goes into a
  1142. GIF file are rather complex, and CompuServe holds the copyright
  1143. to much of the documentation.  The PICS forum on CompuServe (type
  1144. "go pics" at any exclamation mark prompt) will provide GIF
  1145. documentation and much more in the way of useful information to
  1146. graphics programmers if you fill out a simple developer's
  1147. registration form.  Another place to look for GIF information is
  1148. the Autodesk forum on CompuServe; type "go autodesk" to learn
  1149. more.
  1150.  
  1151. 8.3 Cel Files (.CEL and .PIC)
  1152.  
  1153.      A cel file has a 32-byte header followed by the uncompressed
  1154. color map (768 bytes) followed by the uncompressed pixel image.  
  1155.  
  1156.      The header is:
  1157.      Byte Offset    Contents
  1158.            0        Magic Number - 9119 Hexadecimal
  1159.            2        Width of cel
  1160.            4        Height of cel
  1161.            6        Horizontal screen position of upper left
  1162.                     corner
  1163.            8        Vertical screen position  10Number of bits in a pixel (8)
  1164.            11       Compression type (0 for uncompressed)
  1165.            12       Size in bytes of cel image (a 4-byte long
  1166.                     word)
  1167.            16       16 bytes of zero reserved for future use.
  1168.  
  1169.      A .PIC file uses the same format, with width and height
  1170. 320x200 and screen position 0x0.  (.PIC files are generated in
  1171. Autodesk Animator if you supply a .PIC file suffix while loading
  1172. or saving a single frame.  Otherwise a GIF file is made.)
  1173.  
  1174. 8.4 Palette Files (.COL)
  1175.  
  1176.      A color file is just a binary image of the color palette. 
  1177. It consists of 768 bytes -- three bytes for each color.  Each
  1178. byte has a value from 0 to 63.  The red byte comes first, then
  1179. the green, then the blue.
  1180.  
  1181. 8.5 Mask Files (.MSK)
  1182.  
  1183.      A mask file is is an 8000-byte file.  It contains one bit
  1184. for each pixel of the screen.  It goes from left to right, top to
  1185. bottom.
  1186.  
  1187. 8.6 Text Files (.TXT)
  1188.  
  1189.    These are just ordinary ASCII files.
  1190.  
  1191. 8.7 Font Files (.FNT)
  1192.  
  1193.      My font files are a slightly strange hybrid.  They started
  1194. out as the same type of file that GEM on the ST uses.  Then some
  1195. additions were made to make it easier to convert MacIntosh fonts
  1196. to a format Autodesk Animator could use.  My apologies for
  1197. creating yet another font file format for the PC (this only makes
  1198. about 12 I know of...), especially as I don't completely
  1199. understand this one myself!
  1200.  
  1201.      A font file starts out with an 88-byte header.  This is
  1202. followed by up to three tables of various sizes:  
  1203.      Byte Offset    Name      Meaning
  1204.           0         id        Identifier.  Hex 9000 if
  1205.                               Mac-converted
  1206.           2         size      Point size of font.  Not used by
  1207.                               Animator
  1208.           4         facename  32 byte name of font.  Not used by
  1209.                               Animator
  1210.           36        ADE_lo    Lowest ASCII character in font.  
  1211.                               More often than not this is 20 hex
  1212.                               (space character).
  1213.           38        ADE_hi    Highest character in font.
  1214.           40        top_dist  unknown, unused by Animator 42asc_distunknown, unused by Animator
  1215.           44        hlf_dist  unknown, unused by Animator
  1216.           46        des_dist  unknown, unused by Animator
  1217.           48        bot_dist  unknown, unused by Animator
  1218.           50        wchr_wdt  widest character width
  1219.           52        wcel_width     widest 'cell' width (includes
  1220.                                    distance to next character)
  1221.           54        lft_ofst  unknown, unused by Animator
  1222.           56        rgt_ofst  if Mac font, is negative of Mac
  1223.                               maxKern value.  Else unknown &
  1224.                               unused.
  1225.           58        thckning  How bold is bold? Unused by
  1226.                               Animator
  1227.           60        undrline  How far down to underline? Unused
  1228.                               by Animator
  1229.           62        lghtng_m  Lightening mask. Mask for light
  1230.                               style.  Unused by Animator
  1231.           64        skewng_m  Skewing mask for italics.  Rotate
  1232.                               line on a 1 bit.  Unused by
  1233.                               Animator
  1234.           66        flags     Will swap bytes of image if bit 2
  1235.                               is non-zero.  (Part of DRI's
  1236.                               attempt to make 8086/68000 work
  1237.                               together.)
  1238.           68        hz_ofst   Unknown, unused in Animator
  1239.           72        ch_ofst   Unknown, unused in Animator
  1240.           76        fnt_dta   Unknown, unused in Animator
  1241.           80        frm_wdt   Byte width of bitmap
  1242.           82        frm_hgt   Pixel height of bitmap
  1243.           84        nxt_fnt   Unknown, unused in Animator
  1244.  
  1245.      The first table is a series of 16-bit words containing the
  1246. horizontal offset into the font bitmap image of the start of each
  1247. letter.  The width of the letter is calculated by subtracting the
  1248. offset of the next character from the offset of current
  1249. character.  There's one offset for each character in the font,
  1250. plus an extra one to give the width of the last character.  This
  1251. table is always present.
  1252.  
  1253.      The second table contains the font image.  This is a single
  1254. bit-map for the whole font (as opposed to a series of bitmaps one
  1255. for each character).  This table is always present.
  1256.  
  1257.      The third table is only present in fonts we've translated
  1258. from the MacIntosh (that is, if the id field in the header is
  1259. hexadecimal 9000).  There are two bytes for each character in the
  1260. font.  If both bytes are FF hexidecimal it is a 'missing
  1261. character', and will not be drawn.  The first byte is added to
  1262. the rgt_ofst field of the header to tell how many pixels to move
  1263. to the right (or left if the result is negative) before drawing
  1264. this character.  The second byte is how many pixels to move to
  1265. the right after drawing this character.
  1266. 8.8 Polygon and Path files (.PLY)
  1267.  
  1268.      A polygon file has an 8-byte header followed by 6 bytes for
  1269. each point of the polygon (2 bytes each x,y,z with z always zero
  1270. currently).
  1271.  
  1272.    Here is the header:
  1273.      Byte Offset    Contents
  1274.      0              16-bit point count
  1275.      2              4 bytes of zero
  1276.      6              1 if polygon closed, 0 otherwise
  1277.      7              Magic number - hex 99
  1278.  
  1279. 8.9 Optics Files (.OPT)
  1280.  
  1281.      An optics file has a 4-byte header followed by a series of
  1282. optical moves records of 50 bytes each.  Each time you click on
  1283. CONTINUE MOVE in the OPTICS menu in Autodesk Animator another
  1284. record is generated.  The header format is:
  1285.      Byte Offset    Contents
  1286.      0              Magic Number - 1A3F Hexadecimal
  1287.      2              Number of moves in this file.  16-bit count
  1288.  
  1289.    Here's the format for an individual record:
  1290.      Byte Offset    Contents
  1291.      0              4 bytes of zero (room for pointer to next
  1292.                     record when it's loaded into memory)
  1293.      4              Spin center.  x/y/z location (16 bits each)
  1294.      10             Spin axis.  x/y/z location (16 bits each)
  1295.      16             Spin turns  x/y/z (16 bits each)
  1296.      22             Intermediate turns.  Two 16-bit words.  These
  1297.                     are values for a conjugation matrix that
  1298.                     corresponds to spin axis.
  1299.      26             Size center x/y/z location (16 bits each)
  1300.      32             x multiplier -- together with x divisor
  1301.                     determines how to stretch along x
  1302.                     (horizontal) dimension
  1303.      34             x divisor
  1304.      36             y multiplier
  1305.      38             y divisor
  1306.      40             both multiplier - applied to both x and y
  1307.                     dimensions
  1308.      42             both divisor
  1309.      44             linear move x/y/z offset (16 bits each)
  1310.  
  1311. 8.10 Record Files (.REC)
  1312.  
  1313.      A record file has a 16-byte header followed by any number of
  1314. 8-byte input records.  The header format is:
  1315.      Byte Offset    Contents
  1316.      0              Magic Number - 0713 Hexadecimal 2long word (4 byte) count of number of input
  1317.                     records
  1318.      6              4 bytes of 0 
  1319.      10             1 if real-time macro, 0 otherwise
  1320.      11             5 bytes of 0
  1321.  
  1322.    The format of a input record is:
  1323.      Byte Offset    Contents
  1324.      0              Time (in 70th of second) from last record if
  1325.                     real-time, 0 otherwise.
  1326.      1              Mouse button state.  Bit 0 is left button,
  1327.                     bit 1 is right button.  (i.e. the value is 3
  1328.                     if both buttons down, 1 if only left button,
  1329.                     0 if no buttons down.)
  1330.      2              16-bit keyboard code if key pressed, 0
  1331.                     otherwise.
  1332.      4              16-bit mouse horizontal position
  1333.      6              16-bit mouse vertical position
  1334.